package com.ruoyi.cs.base.sort.service;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.cs.base.sort.domain.Sort;
import com.ruoyi.cs.base.sort.mapper.SortMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * 客户/供应商分类
 * 业务执行层
 * @author Drj 2021/6/28
 */
@Service
public class SortServiceImpl implements ISortService {
    @Autowired
    private SortMapper sortMapper;


    /**
     * 查询客户/供应商分类
     *
     * @param sort
     * @return
     */
    @Override
    public List<Sort> selectSortList(Sort sort) {
        return sortMapper.selectSortList(sort);
    }

    /**
     * 根据编号查询客户/供应商分类
     *
     * @param sortId 客户/供应商分类编号
     * @return
     */
    @Override
    public Sort selectSortById(Integer sortId) {
        return sortMapper.selectSortById(sortId);
    }

    /**
     * 新增客户/供应商分类
     *
     * @param sort
     * @return
     */
    @Override
    public int insertSort(Sort sort) {
        if (StringUtils.isNotNull(sortMapper.selectSortById(sort.getSortId()))) {
            //已存在
            return 0;
        }
        if (StringUtils.isNull(sort.getSortParentId())) {
            //无父级产品类别
            return sortMapper.insertSort(sort);
        }
        //有父级产品类别
        Sort info = sortMapper.selectSortById(sort.getSortParentId());
        sort.setAncestors(info.getAncestors() + "," + sort.getSortParentId());
        return sortMapper.insertSort(sort);
    }

    /**
     * 更新客户/供应商分类
     *
     * @param sort
     * @return
     */
    @Override
    public int updateSort(Sort sort) {
        if (!StringUtils.isNotNull(sortMapper.selectSortById(sort.getSortId()))) {
            //不存在
            return 0;
        }
        //新的父级客户/供应商分类
        Sort newParentSort = sortMapper.selectSortById(sort.getSortParentId());
        //要更新的客户/供应商分类的旧属性
        Sort oldSort = sortMapper.selectSortById(sort.getSortId());
        if (StringUtils.isNotNull(newParentSort))//存在新的父级客户/供应商分类
        {
            //新的祖级编号
            String newAncestors = newParentSort.getAncestors() + "," + newParentSort.getSortId();
            //旧的祖级编号
            String oldAncestors = oldSort.getAncestors();
            sort.setAncestors(newAncestors);//更新祖级编号
            updateSortChildren(sort.getSortId(), newAncestors, oldAncestors);
        }
        return sortMapper.updateSort(sort);
    }



    /**
     * 修改子级客户/供应商分类关系
     * @param sortId 被修改的客户/供应商分类ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateSortChildren(Integer sortId, String newAncestors, String oldAncestors)
    {
        List<Sort> children = sortMapper.selectChildrenSortById(sortId);
        for (Sort child : children)
        {
            //更新子客户/供应商分类的祖级编号
            child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            sortMapper.updateSortChildren(children);
        }
    }


    /**
     * 删除客户/供应商分类
     * 仅修改删除标志
     *
     * @param sort
     * @return
     */
    @Override
    public int updateSortDeleteFlag(Sort sort) {
        return sortMapper.updateSortDeleteFlag(sort);
    }



}
